package com.af.system.util;

import com.af.system.function.AfExceptionFunction;
import com.af.system.function.AfIfFunction;

import java.util.*;

/**
 * @author : zhenyun.su
 * @comment :
 * @since : 2022/5/19
 */

public abstract class AfExceptionUtils {

    /*
     * @comment : 无文本及null，空格，无字符，则抛出异常
     */
    public static Boolean hasText(String value) {
        isThrow(!AfStringUtils.hasText(value)).throwMessage("value is empty");
        return true;
    }

    /*
     * @comment : 对象为null，则抛出异常
     */
    public static Boolean isEmpty(Object value) {
        isThrow(AfObjectUtils.isEmpty(value)).throwMessage("object is null");
        return false;
    }

    /*
     * @comment : 对AfExceptionFunction接口throwMessage方法的实现，并返回接口
     */
    public static AfExceptionFunction isThrow(boolean b){
        return (message) ->{
            if (b){
                throw new RuntimeException(message);
            }
        };
    }

    /*
     * @comment : 对AfIfFunction接口ifHandle方法的实现，并返回接口
     */
    public static AfIfFunction isIfHandle(Boolean b) {
        return (trueHandle, falseHandle) ->  {
            if (b){
                trueHandle.run();
            }else{
                falseHandle.run();
            }
        };
    }

    //测试方法
    public static void main(String[] args) {
        // isEmpty("null");
        // hasText("dd");
        // AfExceptionUtils.isThrow(false).throwMessage("false");
        AfExceptionUtils.isIfHandle(true).ifHandle(
                ()->{
                    System.out.println("true");
                    },
                ()->{
                    System.out.println("false");
                }
                );
        List<String> words = new ArrayList<>();
        words.add("hello");
        words.add("worlds");
        words.add("af");
        System.out.println(words);
        // 1通过匿名类来实现函数式接口Comparator的方法compare
        // Collections.sort(words, new Comparator<String>(){
        //     @Override
        //     public int compare(String o1, String o2) {
        //         return Integer.compare(o1.length(), o2.length());
        //     }
        // });

        // 2通过lambda表达式，来实现
        // Collections.sort(words, (o1, o2) -> Integer.compare(o1.length(), o2.length()));

        // 3通过方法引用优先于lambda，可基于现成的计算方法的引用来实现
        //   按字符串长度来比较
        Collections.sort(words, Comparator.comparingInt(String::length));

        //    按每个字符的Unicode值来比较
        Collections.sort(words, String::compareTo);

        // forEach 可通过lambda 表达实现一个函数式接口Consumer， 或直接方法引用来
        words.forEach(item->{
            System.out.println(item);
        });

        words.forEach(System.out::println);

        System.out.println(words);

    }
}
